import { ElMessage } from 'element-plus'
import { nextTick } from 'vue'

/**
 * 业务逻辑管理 composable
 * 抽取App.vue中的复杂业务逻辑方法
 */
export function useBusinessLogic({
  // 表单管理相关
  validateCategoryForm,
  validateItemForm,
  validatePageForm,
  getCategoryFormData,
  getItemFormData,
  getPageFormData,
  isEditingCategory,
  isEditingItem,
  isEditingPage,
  closeCategoryForm,
  closeItemForm,
  closePageForm,
  
  // 数据管理相关
  saveCategory,
  saveItem,
  savePage,
  removeCategory,
  removeItem,
  removePage,
  fetchCategories,
  fetchAllData,
  
  // 关系管理相关
  tempCategoryRelations,
  tempItemRelations,
  clearTempRelations,
  manageItemCategoryRelation,
  manageCategoryPageRelation,
  updateCurrentCategoryItems,
  fetchCurrentItemCategories,
  updateAvailableCategoriesForItem,
  
  // 文件上传相关
  saveItemWithFile,
  clearIconPreview,
  
  // UI状态相关
  activeCategoryTab,
  itemFormTab,
  activePageTab,
  iconPreviewUrl,
  iconUploadRef,
  currentCategory,
  currentItemCategories,
  currentRelatedItems,
  availableCategoriesForItem,
  categories,
  items
}) {
  
  // 重写关闭分类表单方法，确保清空临时关联关系
  const handleCloseCategoryForm = () => {
    clearTempRelations()
    closeCategoryForm()
  }

  // 重写关闭项目表单方法，确保清空页面项目关联状态和分类关联状态
  const handleCloseItemForm = () => {
    clearTempRelations()
    closeItemForm()
  }

  // 分类操作
  const handleSaveCategory = async (categoryFormRef) => {
    try {
      await validateCategoryForm(categoryFormRef)
      const formData = getCategoryFormData()
      const isEdit = isEditingCategory()
      
      let result
      // 如果是新建分类且有临时关联关系，使用新的API格式
      if (!isEdit && (tempCategoryRelations.value.pages.length > 0 || tempCategoryRelations.value.items.length > 0)) {
        // 构建包含关联关系的请求数据
        const categoryWithRelations = {
          ...formData,
          page_ids: tempCategoryRelations.value.pages,
          item_ids: tempCategoryRelations.value.items
        }
        
        result = await saveCategory(categoryWithRelations, false)
        ElMessage.success('分类及关联关系保存成功')
      } else {
        // 编辑分类或无关联关系的新建分类，使用原有逻辑
        result = await saveCategory(formData, isEdit)
        
        // 如果是编辑分类，保存后需要确保数据同步
        if (isEdit) {
          await new Promise(resolve => setTimeout(resolve, 100))
          await fetchCategories()
          await updateCurrentCategoryItems()
        }
        
        ElMessage.success(isEdit ? '分类更新成功' : '分类创建成功')
      }
      
      // 清空临时关联关系并关闭表单
      handleCloseCategoryForm()
      
      // 刷新所有数据
      await fetchAllData()
      
    } catch (error) {
      ElMessage.error('分类保存失败，请重试')
    }
  }

  const editCategory = async (category, openCategoryForm, fetchCategories) => {
    openCategoryForm(category)
    // 如果是编辑模式，初始化关系数据
    if (category && category.id) {
      // 设置当前分类，确保关系管理函数能正确工作
      currentCategory.value = category
      // 先刷新分类数据，确保获取最新的关联关系
      await fetchCategories()
      setTimeout(async () => {
          await updateCurrentCategoryItems()
        }, 100)
    } else {
      // 如果是新建模式，清空临时关联关系和当前分类
      currentCategory.value = null
      clearTempRelations()
    }
    // 重置选项卡到基本信息
    activeCategoryTab.value = 'basic'
  }

  // 删除分类操作
  const deleteCategory = async (id) => {
    await removeCategory(id)
  }

  // 项目操作
  const handleSaveItem = async (itemFormRef, itemForm) => {
    try {
      await validateItemForm(itemFormRef)
      const formData = getItemFormData()
      const isEdit = !!formData.id
      
      // 检查是否有图标文件需要上传
      const hasIconFile = itemForm.iconFile
      
      // 收集所有需要关联的分类ID
      const categoriesToLink = new Set()
      
      // 添加基本信息中选择的归属分类
      if (formData.category_id) {
        categoriesToLink.add(formData.category_id)
      }
      
      // 添加关系管理中的临时关联分类
      if (tempItemRelations.value.categories.length > 0) {
        tempItemRelations.value.categories.forEach(id => categoriesToLink.add(id))
      }
      
      let result
      
      // 如果是新建项目
      if (!isEdit) {
        // 富文本类型需要设置特殊字段
        if (formData.content_type === 'rich_text') {
          formData.type = 'rich_text'
          formData.content = '[]' // 空的富文本内容数组
        }
        
        if (hasIconFile) {
          // 使用文件上传方式创建项目
          result = await saveItemWithFile(formData, itemForm.iconFile)
        } else {
          // 使用普通方式创建项目
          result = await saveItem(formData, false)
        }
        
        // 获取新创建的项目ID
        const newItemId = result?.data?.id || result?.id
        
        if (newItemId && categoriesToLink.size > 0) {
          // 为新项目添加分类关联
          for (const categoryId of categoriesToLink) {
            try {
              await manageItemCategoryRelation(categoryId, newItemId, 'add')
            } catch (error) {
              console.error(`添加项目${newItemId}到分类${categoryId}失败:`, error)
            }
          }
          ElMessage.success('项目及关联关系保存成功')
        } else {
          ElMessage.success('项目创建成功')
        }
        
        // 清空临时关联关系和图标
        clearTempRelations()
        clearIconPreview(itemForm)
      } else {
        // 编辑项目
        if (hasIconFile) {
          // 编辑模式下有新图标文件，使用文件上传方式
          result = await saveItemWithFile(formData, itemForm.iconFile, true)
          clearIconPreview(itemForm)
        } else {
          // 编辑模式下无新图标文件，使用普通方式
          result = await saveItem(formData, true)
        }
        ElMessage.success('项目更新成功')
      }
      
      handleCloseItemForm()
    } catch (error) {
      console.error('项目保存失败:', error)
      ElMessage.error('项目保存失败')
    }
  }

  const editItem = async (item, openItemForm, fetchCurrentRelatedItems, resetSelections) => {
    openItemForm(item)
    
    // 处理图标显示逻辑
    if (item && item.icon) {
      iconPreviewUrl.value = item.icon
      // itemForm.iconFile = null // 这个需要在调用处处理
      if (iconUploadRef.value) {
        iconUploadRef.value.clearFiles()
      }
    } else {
      // clearIconPreview(itemForm) // 这个需要在调用处处理
    }
    
    // 如果是编辑模式，初始化关系数据
    if (item && item.id) {
      console.log('editItem - 开始编辑项目:', item)
      setTimeout(async () => {
        await fetchCurrentItemCategories(item.id)
        updateAvailableCategoriesForItem()
        
        if (item.content_type === 'page') {
          await fetchCurrentRelatedItems(item.id)
        } else {
          currentRelatedItems.value = []
        }
      }, 100)
    } else {
      // 新建模式，重置所有关系状态
      clearTempRelations()
      resetSelections()
      currentItemCategories.value = []
      currentRelatedItems.value = []
      setTimeout(() => {
        availableCategoriesForItem.value = categories.value
      }, 100)
    }
    // 重置选项卡到基本信息
    itemFormTab.value = 'basic'
  }

  const deleteItem = async (id) => {
    await removeItem(id)
  }

  // 页面操作
  const handleSavePage = async (pageFormRef) => {
    try {
      await validatePageForm(pageFormRef)
      const formData = getPageFormData()
      const isEdit = isEditingPage()
      await savePage(formData, isEdit)
      closePageForm()
    } catch (error) {
      console.error('页面保存失败:', error)
    }
  }

  const editPage = async (page, openPageForm, fetchHierarchyData, hierarchyData, updateCurrentPageCategories) => {
    console.log('🚨🚨🚨 useBusinessLogic - editPage 被调用 🚨🚨🚨')
    console.log('🔍 useBusinessLogic - page:', page)
    console.log('🔍 useBusinessLogic - 即将调用 openPageForm')
    
    openPageForm(page)
    
    console.log('✅ useBusinessLogic - openPageForm 调用完成')
    
    // 如果是编辑模式，初始化关系数据
    if (page && page.id) {
      // 确保层级数据已加载
      if (!hierarchyData.value || hierarchyData.value.length === 0) {
        await fetchHierarchyData()
      }
      setTimeout(() => {
        updateCurrentPageCategories()
      }, 100)
    }
    // 重置选项卡到基本信息
    activePageTab.value = 'basic'
  }

  const deletePage = async (id) => {
    await removePage(id)
  }

  return {
    handleCloseCategoryForm,
    handleCloseItemForm,
    handleSaveCategory,
    editCategory,
    deleteCategory,
    handleSaveItem,
    editItem,
    deleteItem,
    handleSavePage,
    editPage,
    deletePage
  }
}